feat(core): supply the Grate bridge's index — the read stops being forged - #127

What this changes

MultiFocus[Function1[X0, *]] (the Grate carrier) has exactly one read that no rule of the type
system can serve: the Direct → MultiFocus[Function1[X0, *]] bridge's product must turn a written
bundle X0 => B back into a T, and its own carrier stores only Unit. That read was a
null.asInstanceOf[X0] sentinel guarded by a documented constant-bundle contract. It is now a real,
caller-supplied index.

• data.RepresentativeIndex[X0] (new) — the witness. Shipped instances for the index types the
  Grate factories fix with a canonical value (Int → 0, Boolean → false, Unit → ()), any
  singleton type via ValueOf, and RepresentativeIndex.at(i) for everything else.
• Function1BroadcastOptic stores at and reads there; forgetful2multifocusFunction1 now
  takes the witness.
• unobserved keeps its two remaining sites — both existential leftovers the write path
  discards — and its docstring now states the stronger invariant: neither site is an index.

⚠️ Stacked on an unpublished baseline

The first commit (f7065947) is the sibling baseline change "compose the Function1 (Grate)
carrier positionally" (source branch fix/grate-positional-composition, commit 81a53d3d),
replayed onto main. It is not on main and has not been pushed anywhere; the second commit
cannot compile without its Function1BroadcastOptic / per-index-write kernel work.

If you'd rather review them separately I can push the baseline as its own branch and retarget this
PR onto it — say the word.

Behaviour: nothing user-observable changes (measured, not asserted)

Every shipped path hands that from a constant bundle (modify / replace / collect* map the
optic's own broadcast, and the kernel's fallback passes a constant), so the witness value cannot be
observed through them. The baseline's positional guarantee is also untouched: grate ∘ iso still
rebuilds per index through broadcastFrom, which needs no index at all.

A test pins the read rule itself on a hand-built varying bundle (-1000 at index 0 vs -990 at
index 1) — white-box, because outside eo the carrier's leftover X is abstract, so a caller cannot
even name such a bundle (Found: Unit, Required: bridged.X). That is the honest shape of this
change: it makes an unobservable read structural rather than contract-guarded.

Costs, honestly

• A new public typeclass in implicit position on a shipped Composer. Call sites are unchanged for
  Int / Boolean / Unit / singleton index types (instances resolve off the companion — still no
  imports); a grate over an algebraic index needs given RepresentativeIndex[X] = RepresentativeIndex.at(v).
• Uninhabited index types no longer bridge at all (Function1[Nothing, *], a phantom slot):
  there is no index to witness, so a read that has no answer is refused instead of forged. That is a
  capacity regression in an exotic corner, and it is deliberate.
• The shipped Boolean → false instance does privilege a value. Dropping the shipped
  instances together is the stricter-consistency option: three composition cells go red and every
  caller writes a given.

Relationship to #123 (please read this before deciding)

#123 retired representableAt because "position is a read-time argument, never a property of the
optic" — and its write-up records that giving repr0 runtime meaning would take "a field on the
optic class plus a runtime witness match (the Function1BroadcastOptic shape)". This PR is that
shape, so it has to be the deliberate exception, not a quiet contradiction:

1. .at(i) subsumes a factory's index; nothing subsumes the bridge's. Every read of a built
   Grate optic is caller-driven. The bridge's from is the opposite: the kernel hands it a whole
   bundle and there is no caller to ask — real value at construction, or forged value at the read.
2. A construction-time index is a claim about the optic; a bridge witness is not. repr0 said
   "this optic is at this index" (false — two calls built the same optic). The witness says "if you
   ever have to read a bundle this optic did not build, read it here" — unobservable on every shipped
   path.

If the line's answer is "hold #123's ruling consistently — no index on an optic, ever", then this PR
should be closed rather than merged, and the sentinel stays. Both are recorded in the design note
(§4 for the comparison, §7 for the recommendation with its cost).

Tests / evidence

Design note with the full analysis, the stand-in inventory, the measured candidate supplies
(Representable has no representative index; ValueOf does not cover Int / Boolean) and the
alternative designs: docs/research/2026-09-30-grate-witness-index.md.

• core/testOnly dev.constructive.eo.MultiFocusFunction1Spec — 14 examples / 349 expectations:
  the witness read is observable on a varying bundle; the shipped path is witness-invariant (round
  trip equals identity, modify unaffected) for two different witnesses; grate ∘ iso stays
  positional under a deliberately wrong witness (at(2): (10,20,30) → (11,21,31)); an algebraic
  index bridges off a one-line given; the witness works on refactor(core): retire MultiFocus.representableAt — the repr0 index was unobservable #123's own permuted Tri / Slot
  fixture (index order ≠ field order) with modify still equal to the instance's map; an
  unwitnessed index does not bridge (typeChecks); the shipped instances name real values; the
  Boolean-indexed cell resolves import-free.
• tests/testOnly dev.constructive.eo.{GrateShapeSpec, CompositionMatrixSpec, UnlawfulFixturesSpec}
  — 23 / 121 / 4 examples (the iso ∘ grate cell stays green; no cell moves).
• Full CI gate set locally on JDK 25 (sbt 1.13.0 / Scala 3.9.0):
  scalafmtCheckAll scalafmtSbtCheck benchmarks/scalafmtCheck githubWorkflowCheck mimaReportBinaryIssues test
  → green, scalafixAll --check → green, sbt doc → clean (no new scaladoc warnings),
  docs/mdoc → 0 errors, docs/laikaSite → generated.
• Docs updated in the same commits: multifocus.md (bridge row + the "carries no constraint"
  paragraph), the generated QA grate legend (script and page kept in sync), the Grate grid's header
  comment in GrateShapeSpec, mima.sbt (0.19 break entry per the line's convention), CHANGELOG.md,
  and the core row of the agent guide.

Not benchmarked, by construction: MultiFocusCollectBench drives MultiFocus.tuple directly and
never builds a bridge, so this change cannot appear on that measured path (neither win nor loss).